package demo1;

/**
 * @Author
 * @Description
 */
class Shape{
    public void draw(){
        System.out.println("画图形");
    }
}
class React extends Shape {
    @Override
    public void draw() {
        System.out.println("画一个矩形");
    }
}
class Cycle extends Shape{
    @Override
    public void draw() {
        System.out.println("画一个圆");
    }
}
class Flower extends Shape{
    @Override
    public void draw() {
        System.out.println("画一朵花");
    }
}
class Triangle extends Shape {
    @Override
    public void draw() {
        System.out.println("△");
    }
}

public class Test {
    public static void darwMap1(Shape shape){
        shape.draw();//一个引用调用一个方法，但是结果不一样
    }
    public static void darwMap2() {
        React react = new React();
        Cycle cycle = new Cycle();
        Flower flower = new Flower();
        String[] string = {"cycle", "rect", "cycle", "rect", "flower"};
        for (String s : string) {
            if (s.equals("cycle")) {
                cycle.draw();
            } else if (s.equals("rect")) {
                react.draw();
            } else {
                flower.draw();
            }
        }
        //这种具有很多if-else的结构的代码，这种复杂度叫做圈复杂度
    }

    public static void darwMaps3() {
        React react = new React();
        Cycle cycle = new Cycle();
        Flower flower = new Flower();
        Triangle triangle = new Triangle();
        /*Shape[] shapes = {cycle,react, cycle,react, flower}*/;//发生了向上转型
        Shape[] shapes = {cycle,react, cycle,react, flower,triangle};//扩展能力强，多态的改动的成本非常低，
        //比如只要新添一个子类就可以调用
        for (Shape shape : shapes){
            shape.draw();//这个时候就是发生了动态绑定，那么也是发生了多态
        }
    }
    public static void main1(String[] args) {
        React react = new React();
        Cycle cycle = new Cycle();
        Flower flower = new Flower();
        darwMap1(react);
        darwMap1(cycle);
        darwMap1(flower);
        //原因：引用的对象不一样，所以调用的方法就不一样
    }

    public static void main2(String[] args) {
        darwMap2();
    }

    public static void main(String[] args) {
        darwMaps3();
    }
    //多态：
    //当我们引用的对象不一样，调用同一个重写的方法，表现的行为不一样的这种思想叫做多态

    //多态缺陷：代码的运行效率降低。
    //1. 属性没有多态性
    //当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性
    //2. 构造方法没有多态性

}
